from BloodSpiderModel.DjangoResponseTool.response_dict import response_dict
from BloodSpiderAPI.models import PhoneNumber, PhoneNumberOrder
from BloodSpiderAPI.apis.phone import utils


# 添加手机号
def create_phone_number(request):
    """
    添加新的手机号
    
    请求参数: (POST)
        phone: 手机号
        name: 名称
    
    返回:
        JSON格式的响应，包含创建的手机号信息
    """
    if request.method != 'POST':
        return response_dict(message="请使用POST请求", code=1)
    
    try:
        phone = request.POST.get('phone')
        name = request.POST.get('name')
        
        if not phone:
            return response_dict(message="手机号不能为空", code=1)
        if not name:
            return response_dict(message="名称不能为空", code=1)
        
        # 检查手机号是否已存在
        if PhoneNumber.objects.filter(phone=phone).exists():
            return response_dict(message="手机号已存在", code=1)
        
        # 创建新的手机号记录
        new_phone_number = PhoneNumber.objects.create(
            phone=phone,
            name=name
        )
        
        # 转换为字典格式返回
        response_data = utils.utils_model_to_dict(new_phone_number)
        return response_dict(data=response_data, message="手机号添加成功")
    except Exception as e:
        return response_dict(message=f"添加失败: {str(e)}", code=1)


# 获取手机号列表
def get_phone_number_list(request):
    """
    获取所有手机号列表，包含每个手机号关联的订单信息
    
    返回:
        JSON格式的响应，包含所有手机号信息及关联订单
    """
    if request.method != 'GET':
        return response_dict(message="请使用GET请求", code=1)
    
    try:
        # 获取所有手机号
        phone_numbers = PhoneNumber.objects.all()
        response_data = []
        
        # 遍历每个手机号，添加关联订单信息
        for phone in phone_numbers:
            phone_data = utils.utils_model_to_dict(phone)
            
            # 获取关联的手机订单
            phone_orders = PhoneNumberOrder.objects.filter(phone_number=phone.phone_number_id) or []
            phone_data['phone_orders'] = [utils.utils_model_to_dict(order) for order in phone_orders]
            
            response_data.append(phone_data)
        
        return response_dict(data=response_data, message="获取成功")
    except Exception as e:
        return response_dict(message=f"获取失败: {str(e)}", code=1)


# 获取手机号详情
def get_phone_number(request):
    """
    获取指定手机号的详情
    
    请求参数: (GET)
        phone_number_id: 手机号ID
    
    返回:
        JSON格式的响应，包含手机号详情和关联订单
    """
    if request.method != 'GET':
        return response_dict(message="请使用GET请求", code=1)
    
    try:
        phone_number_id = request.GET.get('phone_number_id')
        if not phone_number_id:
            return response_dict(message="手机号ID不能为空", code=1)
        
        # 获取手机号详情（包含关联订单）
        phone_detail = utils.get_phone_number_detail(phone_number_id)
        if not phone_detail:
            return response_dict(message="手机号不存在", code=1)
        
        return response_dict(data=phone_detail, message="获取成功")
    except Exception as e:
        return response_dict(message=f"获取失败: {str(e)}", code=1)


# 更新手机号
def update_phone_number(request):
    """
    更新指定手机号的信息
    
    请求参数: (POST)
        phone_number_id: 手机号ID
        phone: 新手机号（可选）
        name: 新名称（可选）
        max_orders: 最大接单量（可选）
    
    返回:
        JSON格式的响应，包含更新后的手机号信息
    """
    if request.method != 'POST':
        return response_dict(message="请使用POST请求", code=1)
    
    try:
        phone_number_id = request.POST.get('phone_number_id')
        if not phone_number_id:
            return response_dict(message="手机号ID不能为空", code=1)
        
        # 检查手机号是否存在
        try:
            phone_number = PhoneNumber.objects.get(phone_number_id=phone_number_id)
        except PhoneNumber.DoesNotExist:
            return response_dict(message="手机号不存在", code=1)
        
        # 准备更新数据
        update_data = {}
        if 'phone' in request.POST and request.POST['phone']:
            # 检查新手机号是否已存在（如果不是原手机号）
            if request.POST['phone'] != phone_number.phone and PhoneNumber.objects.filter(phone=request.POST['phone']).exists():
                return response_dict(message="新手机号已存在", code=1)
            update_data['phone'] = request.POST['phone']
        if 'name' in request.POST and request.POST['name']:
            update_data['name'] = request.POST['name']
        if 'max_orders' in request.POST:
            try:
                max_orders = int(request.POST['max_orders'])
                if max_orders < 1:
                    return response_dict(message="最大接单量必须大于0", code=1)
                update_data['max_orders'] = max_orders
            except ValueError:
                return response_dict(message="最大接单量必须是整数", code=1)
        
        # 如果没有任何可更新字段
        if not update_data:
            return response_dict(message="没有提供可更新字段", code=1)
        
        # 更新手机号信息
        PhoneNumber.objects.filter(phone_number_id=phone_number_id).update(**update_data)
        
        # 获取更新后的手机号
        updated_phone = PhoneNumber.objects.get(phone_number_id=phone_number_id)
        response_data = utils.utils_model_to_dict(updated_phone)
        
        return response_dict(data=response_data, message="手机号更新成功")
    except Exception as e:
        return response_dict(message=f"更新失败: {str(e)}", code=1)


# 删除手机号
def delete_phone_number(request):
    """
    删除指定的手机号
    
    请求参数: (POST)
        phone_number_id: 手机号ID
    
    返回:
        JSON格式的响应，包含操作结果
    """
    if request.method != 'POST':
        return response_dict(message="请使用POST请求", code=1)
    
    try:
        phone_number_id = request.POST.get('phone_number_id')
        if not phone_number_id:
            return response_dict(message="手机号ID不能为空", code=1)
        
        # 检查手机号是否存在
        try:
            phone_number = PhoneNumber.objects.get(phone_number_id=phone_number_id)
        except PhoneNumber.DoesNotExist:
            return response_dict(message="手机号不存在", code=1)
        
        # 删除手机号
        phone_number.delete()
        
        return response_dict(message="手机号删除成功")
    except Exception as e:
        return response_dict(message=f"删除失败: {str(e)}", code=1)


# 添加手机号订单
def create_phone_order(request):
    """
    创建手机号关联的订单，包含最大接单量验证
    
    请求参数: (POST)
        phone_number_id: 手机号ID
        order_id: 订单ID
        remark: 备注（可选）
    
    返回:
        JSON格式的响应，包含创建的手机号订单信息
    """
    if request.method != 'POST':
        return response_dict(message="请使用POST请求", code=1)
    
    try:
        phone_number_id = request.POST.get('phone_number_id')
        order_id = request.POST.get('order_id')
        remark = request.POST.get('remark', '')
        
        if not phone_number_id:
            return response_dict(message="手机号ID不能为空", code=1)
        if not order_id:
            return response_dict(message="订单ID不能为空", code=1)
        
        # 检查手机号是否存在
        try:
            phone_number = PhoneNumber.objects.get(phone_number_id=phone_number_id)
        except PhoneNumber.DoesNotExist:
            return response_dict(message="手机号不存在", code=1)
        
        # 检查当前使用中订单数量是否超过最大接单量
        current_pending_orders = PhoneNumberOrder.objects.filter(
            phone_number=phone_number_id,
            status='pending'
        ).count()
        
        if current_pending_orders >= phone_number.max_orders:
            return response_dict(message=f"当前手机号已达到最大接单量({phone_number.max_orders})，无法创建新订单", code=1)
        
        # 创建新的手机号订单记录
        new_phone_order = PhoneNumberOrder.objects.create(
            phone_number=phone_number,
            order_id=order_id,
            remark=remark
        )
        
        # 转换为字典格式返回
        response_data = utils.utils_model_to_dict(new_phone_order)
        return response_dict(data=response_data, message="手机号订单创建成功")
    except Exception as e:
        return response_dict(message=f"创建失败: {str(e)}", code=1)


# 获取手机号订单列表
def get_phone_order_list(request):
    """
    获取所有手机号订单列表
    
    返回:
        JSON格式的响应，包含所有手机号订单信息
    """
    if request.method != 'GET':
        return response_dict(message="请使用GET请求", code=1)
    
    try:
        phone_orders = PhoneNumberOrder.objects.all()
        response_data = [utils.utils_model_to_dict(order) for order in phone_orders]
        return response_dict(data=response_data, message="获取成功")
    except Exception as e:
        return response_dict(message=f"获取失败: {str(e)}", code=1)


# 获取手机号订单详情
def get_phone_order(request):
    """
    获取指定手机号订单的详情
    
    请求参数: (GET)
        phone_order_id: 手机号订单ID
    
    返回:
        JSON格式的响应，包含手机号订单详情
    """
    if request.method != 'GET':
        return response_dict(message="请使用GET请求", code=1)
    
    try:
        phone_order_id = request.GET.get('phone_order_id')
        if not phone_order_id:
            return response_dict(message="手机号订单ID不能为空", code=1)
        
        # 获取手机号订单详情
        phone_order_detail = utils.get_phone_order_detail(phone_order_id)
        if not phone_order_detail:
            return response_dict(message="手机号订单不存在", code=1)
        
        return response_dict(data=phone_order_detail, message="获取成功")
    except Exception as e:
        return response_dict(message=f"获取失败: {str(e)}", code=1)


# 更新手机号订单
def update_phone_order(request):
    """
    更新指定手机号订单的信息
    
    请求参数: (POST)
        phone_order_id: 手机号订单ID
        order_id: 订单ID（可选）
        status: 状态（可选，值为'pending'或'completed'）
        remark: 备注（可选）
    
    返回:
        JSON格式的响应，包含更新后的手机号订单信息
    """
    if request.method != 'POST':
        return response_dict(message="请使用POST请求", code=1)
    
    try:
        phone_order_id = request.POST.get('phone_order_id')
        if not phone_order_id:
            return response_dict(message="手机号订单ID不能为空", code=1)
        
        # 检查手机号订单是否存在
        try:
            phone_order = PhoneNumberOrder.objects.get(phone_order_id=phone_order_id)
        except PhoneNumberOrder.DoesNotExist:
            return response_dict(message="手机号订单不存在", code=1)
        
        # 准备更新数据
        update_data = {}
        if 'order_id' in request.POST and request.POST['order_id']:
            update_data['order_id'] = request.POST['order_id']
        if 'status' in request.POST and request.POST['status']:
            # 验证状态值是否有效
            if request.POST['status'] not in ['pending', 'completed']:
                return response_dict(message="状态值无效，只能是'pending'或'completed'", code=1)
            update_data['status'] = request.POST['status']
        if 'remark' in request.POST:
            update_data['remark'] = request.POST['remark']
        
        # 如果没有任何可更新字段
        if not update_data:
            return response_dict(message="没有提供可更新字段", code=1)
        
        # 更新手机号订单信息
        PhoneNumberOrder.objects.filter(phone_order_id=phone_order_id).update(**update_data)
        
        # 获取更新后的手机号订单
        updated_order = PhoneNumberOrder.objects.get(phone_order_id=phone_order_id)
        response_data = utils.utils_model_to_dict(updated_order)
        
        return response_dict(data=response_data, message="手机号订单更新成功")
    except Exception as e:
        return response_dict(message=f"更新失败: {str(e)}", code=1)


# 删除手机号订单
def delete_phone_order(request):
    """
    删除指定的手机号订单
    
    请求参数: (POST)
        phone_order_id: 手机号订单ID
    
    返回:
        JSON格式的响应，包含操作结果
    """
    if request.method != 'POST':
        return response_dict(message="请使用POST请求", code=1)
    
    try:
        phone_order_id = request.POST.get('phone_order_id')
        if not phone_order_id:
            return response_dict(message="手机号订单ID不能为空", code=1)
        
        # 检查手机号订单是否存在
        try:
            phone_order = PhoneNumberOrder.objects.get(phone_order_id=phone_order_id)
        except PhoneNumberOrder.DoesNotExist:
            return response_dict(message="手机号订单不存在", code=1)
        
        # 删除手机号订单
        phone_order.delete()
        
        return response_dict(message="手机号订单删除成功")
    except Exception as e:
        return response_dict(message=f"删除失败: {str(e)}", code=1)